// 文件路径: dbms/parser/ast/SelectNode.java
package com.dbms.parser.ast;

import com.dbms.common.Constants;
import com.dbms.common.Position;

import java.util.List;

/**
 * SelectNode (查询节点) 代表了 `SELECT` 语句的抽象语法树 (AST) 结构。
 * 这是最复杂的语句节点之一，因为它包含了 `SELECT` 语句所有可能的子句，
 * 如 `FROM`, `WHERE`, `JOIN`, `GROUP BY`, `ORDER BY`, `LIMIT` 等。
 * 【已修改】这个版本新增了 `havingClause` 字段以支持 `HAVING` 子句。
 */
public class SelectNode extends StatementNode {
    /**
     * SELECT 子句中的列或表达式列表。
     * 使用 List<Object> 是因为列表项可以是列名 (String)，也可以是函数调用 (FunctionCallNode)。
     */
    private final List<Object> columns;
    /**
     * FROM 子句中的主表名。
     */
    private final String tableName;
    /**
     * WHERE 子句的条件表达式。
     */
    private final ExpressionNode whereClause;
    /**
     * JOIN 子句。
     */
    private final JoinNode joinNode;
    /**
     * GROUP BY 子句。
     */
    private final GroupByNode groupByNode;
    /**
     * ORDER BY 子句。
     */
    private final OrderByNode orderByNode;
    /**
     * LIMIT / OFFSET 子句。
     */
    private final LimitNode limitNode;
    /**
     * 【新增字段】HAVING 子句的条件表达式。
     */
    private final ExpressionNode havingClause;

    /**
     * 构造函数，用于创建一个包含所有子句的 SelectNode。
     * @param position 语句在原始 SQL 中的位置
     * @param columns SELECT 的列/表达式列表
     * @param tableName FROM 的表名
     * @param whereClause WHERE 子句
     * @param joinNode JOIN 子句
     * @param groupByNode GROUP BY 子句
     * @param orderByNode ORDER BY 子句
     * @param limitNode LIMIT 子句
     * @param havingClause HAVING 子句
     */
    public SelectNode(Position position, List<Object> columns, String tableName, ExpressionNode whereClause,
                      JoinNode joinNode, GroupByNode groupByNode, OrderByNode orderByNode, LimitNode limitNode, ExpressionNode havingClause) {
        super(position);
        this.columns = columns;
        this.tableName = tableName;
        this.whereClause = whereClause;
        this.joinNode = joinNode;
        this.groupByNode = groupByNode;
        this.orderByNode = orderByNode;
        this.limitNode = limitNode;
        this.havingClause = havingClause; // 初始化新增字段
    }

    @Override
    public String getStatementType() {
        return Constants.STATEMENT_SELECT;
    }

    public List<Object> getColumns() {
        return columns;
    }

    public String getTableName() {
        return tableName;
    }

    public ExpressionNode getWhereClause() {
        return whereClause;
    }

    public JoinNode getJoinNode() {
        return joinNode;
    }

    public GroupByNode getGroupByNode() {
        return groupByNode;
    }

    public OrderByNode getOrderByNode() {
        return orderByNode;
    }

    public LimitNode getLimitNode() {
        return limitNode;
    }

    /**
     * 【新增 Getter】获取 HAVING 子句的表达式节点。
     * @return 代表 HAVING 条件的 ExpressionNode
     */
    public ExpressionNode getHavingClause() {
        return havingClause;
    }

    @Override
    public String toString() {
        return "SelectNode{\n" +
                "    columns=" + columns + ",\n" +
                "    tableName='" + tableName + "',\n" +
                "    whereClause='" + (whereClause != null ? whereClause.toString() : "无") + "'\n" +
                "}";
    }
}